﻿using System;
using System.Collections.Generic;

using System.Text;

namespace Rance.Battle
{
    class 策士AI : AI
    {
        public override AIResult Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            List<AIResult> list = new List<AIResult>();

            var result1 = 伪报Excute(角色, 队伍状况, 技能mgt);
            if (result1 != null)
                list.Add(result1);

            var result2 = 空城计Excute(角色, 队伍状况, 技能mgt);
            if (result2 != null)
                list.Add(result2);

            var result3 = 运筹帷幄Excute(角色, 队伍状况, 技能mgt);
            if (result3 != null)
                list.Add(result3);

            var result4 = 锦囊妙计Excute(角色, 队伍状况, 技能mgt);
            if (result4 != null)
                list.Add(result4);

            if (list.Count == 1)
            {
                if (队伍状况.战场.AI乱数表.Hit(90))
                    return list[0];
            }
            else if (list.Count == 2)
            {
                if (队伍状况.战场.AI乱数表.Hit(50))
                    return list[0];
                else
                    return list[1];
            }

            return 弓箭射击Excute(角色, 队伍状况, 技能mgt);
        }

        private static 策士AI instance = new 策士AI();
        public static 策士AI GetInstance()
        {
            return instance;
        }

        protected AIResult 弓箭射击Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            var 弓箭射击 = 技能mgt.Get("弓箭射击");
            var 弓箭射击target = getTarget(ConvertSoloTarget(弓箭射击.TargetList), 队伍状况, 角色);
            result.Action = 弓箭射击.Name;
            result.TargetList.Add(弓箭射击target);

            return result;

        }

        private 角色 getTarget(List<角色> targetList, 队伍状况 队伍状况, 角色 角色)
        {
            //优先攻击"准备中"的敌人
            List<角色> tempList = targetList.FindAll(r => r.是否准备);
            if (tempList.Count == 1)
                return targetList[0];
            else if (tempList.Count > 1)
            {
                var value = 队伍状况.战场.AI乱数表.Random(0, tempList.Count);
                return tempList[value];
            }

            //撇除"步卒"敌人
            tempList.Clear();
            foreach (var item in targetList)
            {
                if (item.兵种.类型 == "步卒")
                    continue;

                tempList.Add(item);
            }

            if (tempList.Count != 0)
                targetList = tempList;

            if (targetList.Count == 1)
                return targetList[0];
            else
            {
                //优先攻击准备中的敌人

                List<角色> temp2List = new List<角色>();
                foreach (var item in tempList)
                {
                    if (item.是否准备)
                    {
                        tempList.Add(item);
                        break;
                    }
                }
                if (temp2List.Count == 1)
                    return temp2List[0];

                var value = 队伍状况.战场.AI乱数表.Random(0, targetList.Count);
                return targetList[value];
            }
        }

        protected AIResult 伪报Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("伪报"))
            {
                var 伪报 = 技能mgt.Get("伪报");
                result.Action = 伪报.Name;
                result.TargetList = 伪报.TargetList[0].List;

                return result;
            }

            return null;
        }

        protected AIResult 空城计Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("空城计"))
            {
                var 空城计 = 技能mgt.Get("空城计");
                result.Action = 空城计.Name;
                result.TargetList = 空城计.TargetList[0].List;

                return result;
            }

            return null;
        }

        protected AIResult 运筹帷幄Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("运筹帷幄"))
            {
                var 运筹帷幄 = 技能mgt.Get("运筹帷幄");
                result.Action = 运筹帷幄.Name;
                result.TargetList = 运筹帷幄.TargetList[0].List;

                return result;
            }

            return null;
        }

        protected AIResult 锦囊妙计Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();

            if (技能mgt.Has("锦囊妙计1"))
            {
                var list = 队伍状况.队伍.成员List.FindAll(r => !r.是否败退 && r.是否完结);
                if (list.Count > 0)
                {
                    list.Sort((v1, v2) => v1.兵力.CompareTo(v2.兵力));
                    var 锦囊妙计 = 技能mgt.Get("锦囊妙计1");
                    result.Action = 锦囊妙计.Name;
                    result.TargetList.Add(list[list.Count - 1]);

                    return result;
                }
            }

            if (技能mgt.Has("锦囊妙计2"))
            {
                var list = 队伍状况.队伍.成员List.FindAll(r => !r.是否败退 && r.是否完结);
                if (list.Count > 1)
                {
                    var 锦囊妙计 = 技能mgt.Get("锦囊妙计2");
                    result.Action = 锦囊妙计.Name;
                    result.TargetList = list; 

                    return result;
                }
            }

            return null;
        }
    }
}
